home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / Box2D / Collision / Shapes / _bs125.as next >
Encoding:
Text File  |  2010-05-14  |  19.3 KB  |  540 lines
  1. package Box2D.Collision.Shapes
  2. {
  3.    import Box2D.Collision.*;
  4.    import Box2D.Common.*;
  5.    import Box2D.Common.Math.*;
  6.    import Box2D.Dynamics.*;
  7.    
  8.    public class _bs125 extends _hx306
  9.    {
  10.       private static var s_computeMat:_oh327 = new _oh327();
  11.       
  12.       private static var s_sweptAABB1:_pv475 = new _pv475();
  13.       
  14.       private static var s_sweptAABB2:_pv475 = new _pv475();
  15.       
  16.       public var m_vertices:Array;
  17.       
  18.       private var s_supportVec:b2Vec2;
  19.       
  20.       public var m_normals:Array;
  21.       
  22.       public var m_obb:_ik102;
  23.       
  24.       public var m_coreVertices:Array;
  25.       
  26.       public var m_centroid:b2Vec2;
  27.       
  28.       public var m_vertexCount:int;
  29.       
  30.       public function _bs125(param1:_sw544)
  31.       {
  32.          var _loc2_:_mo808 = null;
  33.          var _loc3_:int = 0;
  34.          var _loc4_:int = 0;
  35.          var _loc5_:int = 0;
  36.          var _loc6_:Number = NaN;
  37.          var _loc7_:Number = NaN;
  38.          var _loc8_:Number = NaN;
  39.          var _loc9_:Number = NaN;
  40.          var _loc10_:Number = NaN;
  41.          var _loc11_:Number = NaN;
  42.          var _loc12_:Number = NaN;
  43.          var _loc13_:Number = NaN;
  44.          var _loc14_:Number = NaN;
  45.          var _loc15_:Number = NaN;
  46.          var _loc16_:Number = NaN;
  47.          var _loc17_:Number = NaN;
  48.          s_supportVec = new b2Vec2();
  49.          m_obb = new _ik102();
  50.          m_vertices = new Array(_kc225.b2_maxPolygonVertices);
  51.          m_normals = new Array(_kc225.b2_maxPolygonVertices);
  52.          m_coreVertices = new Array(_kc225.b2_maxPolygonVertices);
  53.          super(param1);
  54.          m_type = e_polygonShape;
  55.          _loc2_ = param1 as _mo808;
  56.          m_vertexCount = _loc2_.vertexCount;
  57.          _loc4_ = _loc3_;
  58.          _loc5_ = _loc3_;
  59.          _loc3_ = 0;
  60.          while(_loc3_ < m_vertexCount)
  61.          {
  62.             m_vertices[_loc3_] = _loc2_.vertices[_loc3_]._ib196();
  63.             _loc3_++;
  64.          }
  65.          _loc3_ = 0;
  66.          while(_loc3_ < m_vertexCount)
  67.          {
  68.             _loc4_ = _loc3_;
  69.             _loc5_ = _loc3_ + 1 < m_vertexCount ? _loc3_ + 1 : 0;
  70.             _loc6_ = m_vertices[_loc5_].x - m_vertices[_loc4_].x;
  71.             _loc7_ = m_vertices[_loc5_].y - m_vertices[_loc4_].y;
  72.             _loc8_ = Math.sqrt(_loc6_ * _loc6_ + _loc7_ * _loc7_);
  73.             m_normals[_loc3_] = new b2Vec2(_loc7_ / _loc8_,-_loc6_ / _loc8_);
  74.             _loc3_++;
  75.          }
  76.          m_centroid = _yi171(_loc2_.vertices,_loc2_.vertexCount);
  77.          _ij772(m_obb,m_vertices,m_vertexCount);
  78.          _loc3_ = 0;
  79.          while(_loc3_ < m_vertexCount)
  80.          {
  81.             _loc4_ = _loc3_ - 1 >= 0 ? _loc3_ - 1 : m_vertexCount - 1;
  82.             _loc5_ = _loc3_;
  83.             _loc9_ = Number(m_normals[_loc4_].x);
  84.             _loc10_ = Number(m_normals[_loc4_].y);
  85.             _loc11_ = Number(m_normals[_loc5_].x);
  86.             _loc12_ = Number(m_normals[_loc5_].y);
  87.             _loc13_ = m_vertices[_loc3_].x - m_centroid.x;
  88.             _loc14_ = m_vertices[_loc3_].y - m_centroid.y;
  89.             _loc15_ = _loc9_ * _loc13_ + _loc10_ * _loc14_ - _kc225.b2_toiSlop;
  90.             _loc16_ = _loc11_ * _loc13_ + _loc12_ * _loc14_ - _kc225.b2_toiSlop;
  91.             _loc17_ = 1 / (_loc9_ * _loc12_ - _loc10_ * _loc11_);
  92.             m_coreVertices[_loc3_] = new b2Vec2(_loc17_ * (_loc12_ * _loc15_ - _loc10_ * _loc16_) + m_centroid.x,_loc17_ * (_loc9_ * _loc16_ - _loc11_ * _loc15_) + m_centroid.y);
  93.             _loc3_++;
  94.          }
  95.       }
  96.       
  97.       public static function _ij772(param1:_ik102, param2:Array, param3:int) : void
  98.       {
  99.          var _loc4_:int = 0;
  100.          var _loc5_:Array = null;
  101.          var _loc6_:Number = NaN;
  102.          var _loc7_:b2Vec2 = null;
  103.          var _loc8_:Number = NaN;
  104.          var _loc9_:Number = NaN;
  105.          var _loc10_:Number = NaN;
  106.          var _loc11_:Number = NaN;
  107.          var _loc12_:Number = NaN;
  108.          var _loc13_:Number = NaN;
  109.          var _loc14_:Number = NaN;
  110.          var _loc15_:Number = NaN;
  111.          var _loc16_:Number = NaN;
  112.          var _loc17_:int = 0;
  113.          var _loc18_:Number = NaN;
  114.          var _loc19_:Number = NaN;
  115.          var _loc20_:Number = NaN;
  116.          var _loc21_:Number = NaN;
  117.          var _loc22_:Number = NaN;
  118.          var _loc23_:Number = NaN;
  119.          var _loc24_:Number = NaN;
  120.          var _loc25_:_oh327 = null;
  121.          _loc5_ = new Array(_kc225.b2_maxPolygonVertices + 1);
  122.          _loc4_ = 0;
  123.          while(_loc4_ < param3)
  124.          {
  125.             _loc5_[_loc4_] = param2[_loc4_];
  126.             _loc4_++;
  127.          }
  128.          _loc5_[param3] = _loc5_[0];
  129.          _loc6_ = Number.MAX_VALUE;
  130.          _loc4_ = 1;
  131.          while(_loc4_ <= param3)
  132.          {
  133.             _loc7_ = _loc5_[int(_loc4_ - 1)];
  134.             _loc8_ = _loc5_[_loc4_].x - _loc7_.x;
  135.             _loc9_ = _loc5_[_loc4_].y - _loc7_.y;
  136.             _loc10_ = Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_);
  137.             _loc8_ /= _loc10_;
  138.             _loc9_ /= _loc10_;
  139.             _loc11_ = -_loc9_;
  140.             _loc12_ = _loc8_;
  141.             _loc13_ = Number.MAX_VALUE;
  142.             _loc14_ = Number.MAX_VALUE;
  143.             _loc15_ = -Number.MAX_VALUE;
  144.             _loc16_ = -Number.MAX_VALUE;
  145.             _loc17_ = 0;
  146.             while(_loc17_ < param3)
  147.             {
  148.                _loc19_ = _loc5_[_loc17_].x - _loc7_.x;
  149.                _loc20_ = _loc5_[_loc17_].y - _loc7_.y;
  150.                _loc21_ = _loc8_ * _loc19_ + _loc9_ * _loc20_;
  151.                _loc22_ = _loc11_ * _loc19_ + _loc12_ * _loc20_;
  152.                if(_loc21_ < _loc13_)
  153.                {
  154.                   _loc13_ = _loc21_;
  155.                }
  156.                if(_loc22_ < _loc14_)
  157.                {
  158.                   _loc14_ = _loc22_;
  159.                }
  160.                if(_loc21_ > _loc15_)
  161.                {
  162.                   _loc15_ = _loc21_;
  163.                }
  164.                if(_loc22_ > _loc16_)
  165.                {
  166.                   _loc16_ = _loc22_;
  167.                }
  168.                _loc17_++;
  169.             }
  170.             _loc18_ = (_loc15_ - _loc13_) * (_loc16_ - _loc14_);
  171.             if(_loc18_ < 0.95 * _loc6_)
  172.             {
  173.                _loc6_ = _loc18_;
  174.                param1.R.col1.x = _loc8_;
  175.                param1.R.col1.y = _loc9_;
  176.                param1.R.col2.x = _loc11_;
  177.                param1.R.col2.y = _loc12_;
  178.                _loc23_ = 0.5 * (_loc13_ + _loc15_);
  179.                _loc24_ = 0.5 * (_loc14_ + _loc16_);
  180.                _loc25_ = param1.R;
  181.                param1.center.x = _loc7_.x + (_loc25_.col1.x * _loc23_ + _loc25_.col2.x * _loc24_);
  182.                param1.center.y = _loc7_.y + (_loc25_.col1.y * _loc23_ + _loc25_.col2.y * _loc24_);
  183.                param1.extents.x = 0.5 * (_loc15_ - _loc13_);
  184.                param1.extents.y = 0.5 * (_loc16_ - _loc14_);
  185.             }
  186.             _loc4_++;
  187.          }
  188.       }
  189.       
  190.       public static function _yi171(param1:Array, param2:int) : b2Vec2
  191.       {
  192.          var _loc3_:b2Vec2 = null;
  193.          var _loc4_:Number = NaN;
  194.          var _loc5_:Number = NaN;
  195.          var _loc6_:Number = NaN;
  196.          var _loc7_:Number = NaN;
  197.          var _loc8_:int = 0;
  198.          var _loc9_:b2Vec2 = null;
  199.          var _loc10_:b2Vec2 = null;
  200.          var _loc11_:Number = NaN;
  201.          var _loc12_:Number = NaN;
  202.          var _loc13_:Number = NaN;
  203.          var _loc14_:Number = NaN;
  204.          var _loc15_:Number = NaN;
  205.          var _loc16_:Number = NaN;
  206.          _loc3_ = new b2Vec2();
  207.          _loc4_ = 0;
  208.          _loc5_ = 0;
  209.          _loc6_ = 0;
  210.          _loc7_ = 1 / 3;
  211.          _loc8_ = 0;
  212.          while(_loc8_ < param2)
  213.          {
  214.             _loc9_ = param1[_loc8_];
  215.             _loc10_ = _loc8_ + 1 < param2 ? param1[int(_loc8_ + 1)] : param1[0];
  216.             _loc11_ = _loc9_.x - _loc5_;
  217.             _loc12_ = _loc9_.y - _loc6_;
  218.             _loc13_ = _loc10_.x - _loc5_;
  219.             _loc14_ = _loc10_.y - _loc6_;
  220.             _loc15_ = _loc11_ * _loc14_ - _loc12_ * _loc13_;
  221.             _loc16_ = 0.5 * _loc15_;
  222.             _loc4_ += _loc16_;
  223.             _loc3_.x += _loc16_ * _loc7_ * (_loc5_ + _loc9_.x + _loc10_.x);
  224.             _loc3_.y += _loc16_ * _loc7_ * (_loc6_ + _loc9_.y + _loc10_.y);
  225.             _loc8_++;
  226.          }
  227.          _loc3_.x *= 1 / _loc4_;
  228.          _loc3_.y *= 1 / _loc4_;
  229.          return _loc3_;
  230.       }
  231.       
  232.       override public function _se554(param1:_fh319) : void
  233.       {
  234.          var _loc2_:Number = NaN;
  235.          var _loc3_:Number = NaN;
  236.          var _loc4_:Number = NaN;
  237.          var _loc5_:Number = NaN;
  238.          var _loc6_:Number = NaN;
  239.          var _loc7_:Number = NaN;
  240.          var _loc8_:Number = NaN;
  241.          var _loc9_:int = 0;
  242.          var _loc10_:b2Vec2 = null;
  243.          var _loc11_:b2Vec2 = null;
  244.          var _loc12_:Number = NaN;
  245.          var _loc13_:Number = NaN;
  246.          var _loc14_:Number = NaN;
  247.          var _loc15_:Number = NaN;
  248.          var _loc16_:Number = NaN;
  249.          var _loc17_:Number = NaN;
  250.          var _loc18_:Number = NaN;
  251.          var _loc19_:Number = NaN;
  252.          var _loc20_:Number = NaN;
  253.          var _loc21_:Number = NaN;
  254.          var _loc22_:Number = NaN;
  255.          var _loc23_:Number = NaN;
  256.          var _loc24_:Number = NaN;
  257.          var _loc25_:Number = NaN;
  258.          _loc2_ = 0;
  259.          _loc3_ = 0;
  260.          _loc4_ = 0;
  261.          _loc5_ = 0;
  262.          _loc6_ = 0;
  263.          _loc7_ = 0;
  264.          _loc8_ = 1 / 3;
  265.          _loc9_ = 0;
  266.          while(_loc9_ < m_vertexCount)
  267.          {
  268.             _loc10_ = m_vertices[_loc9_];
  269.             _loc11_ = _loc9_ + 1 < m_vertexCount ? m_vertices[int(_loc9_ + 1)] : m_vertices[0];
  270.             _loc12_ = _loc10_.x - _loc6_;
  271.             _loc13_ = _loc10_.y - _loc7_;
  272.             _loc14_ = _loc11_.x - _loc6_;
  273.             _loc15_ = _loc11_.y - _loc7_;
  274.             _loc16_ = _loc12_ * _loc15_ - _loc13_ * _loc14_;
  275.             _loc17_ = 0.5 * _loc16_;
  276.             _loc4_ += _loc17_;
  277.             _loc2_ += _loc17_ * _loc8_ * (_loc6_ + _loc10_.x + _loc11_.x);
  278.             _loc3_ += _loc17_ * _loc8_ * (_loc7_ + _loc10_.y + _loc11_.y);
  279.             _loc18_ = _loc6_;
  280.             _loc19_ = _loc7_;
  281.             _loc20_ = _loc12_;
  282.             _loc21_ = _loc13_;
  283.             _loc22_ = _loc14_;
  284.             _loc23_ = _loc15_;
  285.             _loc24_ = _loc8_ * (0.25 * (_loc20_ * _loc20_ + _loc22_ * _loc20_ + _loc22_ * _loc22_) + (_loc18_ * _loc20_ + _loc18_ * _loc22_)) + 0.5 * _loc18_ * _loc18_;
  286.             _loc25_ = _loc8_ * (0.25 * (_loc21_ * _loc21_ + _loc23_ * _loc21_ + _loc23_ * _loc23_) + (_loc19_ * _loc21_ + _loc19_ * _loc23_)) + 0.5 * _loc19_ * _loc19_;
  287.             _loc5_ += _loc16_ * (_loc24_ + _loc25_);
  288.             _loc9_++;
  289.          }
  290.          param1.mass = m_density * _loc4_;
  291.          _loc2_ *= 1 / _loc4_;
  292.          _loc3_ *= 1 / _loc4_;
  293.          param1.center._br741(_loc2_,_loc3_);
  294.          param1.I = m_density * _loc5_;
  295.       }
  296.       
  297.       public function _bm808() : _ik102
  298.       {
  299.          return m_obb;
  300.       }
  301.       
  302.       public function _sv339() : Array
  303.       {
  304.          return m_coreVertices;
  305.       }
  306.       
  307.       public function _gd677(param1:_ni781, param2:Number, param3:Number) : b2Vec2
  308.       {
  309.          var _loc4_:b2Vec2 = null;
  310.          var _loc5_:_oh327 = null;
  311.          var _loc6_:Number = NaN;
  312.          var _loc7_:Number = NaN;
  313.          var _loc8_:int = 0;
  314.          var _loc9_:Number = NaN;
  315.          var _loc10_:int = 0;
  316.          var _loc11_:Number = NaN;
  317.          _loc5_ = param1.R;
  318.          _loc6_ = param2 * _loc5_.col1.x + param3 * _loc5_.col1.y;
  319.          _loc7_ = param2 * _loc5_.col2.x + param3 * _loc5_.col2.y;
  320.          _loc8_ = 0;
  321.          _loc4_ = m_coreVertices[0];
  322.          _loc9_ = _loc4_.x * _loc6_ + _loc4_.y * _loc7_;
  323.          _loc10_ = 1;
  324.          while(_loc10_ < m_vertexCount)
  325.          {
  326.             _loc4_ = m_coreVertices[_loc10_];
  327.             _loc11_ = _loc4_.x * _loc6_ + _loc4_.y * _loc7_;
  328.             if(_loc11_ > _loc9_)
  329.             {
  330.                _loc8_ = _loc10_;
  331.                _loc9_ = _loc11_;
  332.             }
  333.             _loc10_++;
  334.          }
  335.          _loc5_ = param1.R;
  336.          _loc4_ = m_coreVertices[_loc8_];
  337.          s_supportVec.x = param1.position.x + (_loc5_.col1.x * _loc4_.x + _loc5_.col2.x * _loc4_.y);
  338.          s_supportVec.y = param1.position.y + (_loc5_.col1.y * _loc4_.x + _loc5_.col2.y * _loc4_.y);
  339.          return s_supportVec;
  340.       }
  341.       
  342.       public function _px512() : int
  343.       {
  344.          return m_vertexCount;
  345.       }
  346.       
  347.       override public function _yf138(param1:_ni781, param2:Array, param3:b2Vec2, param4:_sn334, param5:Number) : Boolean
  348.       {
  349.          var _loc6_:Number = NaN;
  350.          var _loc7_:Number = NaN;
  351.          var _loc8_:Number = NaN;
  352.          var _loc9_:Number = NaN;
  353.          var _loc10_:_oh327 = null;
  354.          var _loc11_:b2Vec2 = null;
  355.          var _loc12_:Number = NaN;
  356.          var _loc13_:Number = NaN;
  357.          var _loc14_:Number = NaN;
  358.          var _loc15_:Number = NaN;
  359.          var _loc16_:Number = NaN;
  360.          var _loc17_:Number = NaN;
  361.          var _loc18_:int = 0;
  362.          var _loc19_:int = 0;
  363.          var _loc20_:Number = NaN;
  364.          var _loc21_:Number = NaN;
  365.          _loc6_ = 0;
  366.          _loc7_ = param5;
  367.          _loc8_ = param4.p1.x - param1.position.x;
  368.          _loc9_ = param4.p1.y - param1.position.y;
  369.          _loc10_ = param1.R;
  370.          _loc12_ = _loc8_ * _loc10_.col1.x + _loc9_ * _loc10_.col1.y;
  371.          _loc13_ = _loc8_ * _loc10_.col2.x + _loc9_ * _loc10_.col2.y;
  372.          _loc8_ = param4.p2.x - param1.position.x;
  373.          _loc9_ = param4.p2.y - param1.position.y;
  374.          _loc10_ = param1.R;
  375.          _loc14_ = _loc8_ * _loc10_.col1.x + _loc9_ * _loc10_.col1.y;
  376.          _loc15_ = _loc8_ * _loc10_.col2.x + _loc9_ * _loc10_.col2.y;
  377.          _loc16_ = _loc14_ - _loc12_;
  378.          _loc17_ = _loc15_ - _loc13_;
  379.          _loc18_ = -1;
  380.          _loc19_ = 0;
  381.          while(_loc19_ < m_vertexCount)
  382.          {
  383.             _loc11_ = m_vertices[_loc19_];
  384.             _loc8_ = _loc11_.x - _loc12_;
  385.             _loc9_ = _loc11_.y - _loc13_;
  386.             _loc11_ = m_normals[_loc19_];
  387.             _loc20_ = _loc11_.x * _loc8_ + _loc11_.y * _loc9_;
  388.             _loc21_ = _loc11_.x * _loc16_ + _loc11_.y * _loc17_;
  389.             if(_loc21_ < 0 && _loc20_ < _loc6_ * _loc21_)
  390.             {
  391.                _loc6_ = _loc20_ / _loc21_;
  392.                _loc18_ = _loc19_;
  393.             }
  394.             else if(_loc21_ > 0 && _loc20_ < _loc7_ * _loc21_)
  395.             {
  396.                _loc7_ = _loc20_ / _loc21_;
  397.             }
  398.             if(_loc7_ < _loc6_)
  399.             {
  400.                return false;
  401.             }
  402.             _loc19_++;
  403.          }
  404.          if(_loc18_ >= 0)
  405.          {
  406.             param2[0] = _loc6_;
  407.             _loc10_ = param1.R;
  408.             _loc11_ = m_normals[_loc18_];
  409.             param3.x = _loc10_.col1.x * _loc11_.x + _loc10_.col2.x * _loc11_.y;
  410.             param3.y = _loc10_.col1.y * _loc11_.x + _loc10_.col2.y * _loc11_.y;
  411.             return true;
  412.          }
  413.          return false;
  414.       }
  415.       
  416.       public function _in387() : Array
  417.       {
  418.          return m_normals;
  419.       }
  420.       
  421.       override public function _mb454(param1:_pv475, param2:_ni781) : void
  422.       {
  423.          var _loc3_:_oh327 = null;
  424.          var _loc4_:b2Vec2 = null;
  425.          var _loc5_:_oh327 = null;
  426.          var _loc6_:_oh327 = null;
  427.          var _loc7_:Number = NaN;
  428.          var _loc8_:Number = NaN;
  429.          var _loc9_:Number = NaN;
  430.          var _loc10_:Number = NaN;
  431.          _loc5_ = s_computeMat;
  432.          _loc3_ = param2.R;
  433.          _loc4_ = m_obb.R.col1;
  434.          _loc5_.col1.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  435.          _loc5_.col1.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  436.          _loc4_ = m_obb.R.col2;
  437.          _loc5_.col2.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  438.          _loc5_.col2.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  439.          _loc5_._hj410();
  440.          _loc6_ = _loc5_;
  441.          _loc4_ = m_obb.extents;
  442.          _loc7_ = _loc6_.col1.x * _loc4_.x + _loc6_.col2.x * _loc4_.y;
  443.          _loc8_ = _loc6_.col1.y * _loc4_.x + _loc6_.col2.y * _loc4_.y;
  444.          _loc3_ = param2.R;
  445.          _loc4_ = m_obb.center;
  446.          _loc9_ = param2.position.x + (_loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y);
  447.          _loc10_ = param2.position.y + (_loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y);
  448.          param1.lowerBound._br741(_loc9_ - _loc7_,_loc10_ - _loc8_);
  449.          param1.upperBound._br741(_loc9_ + _loc7_,_loc10_ + _loc8_);
  450.       }
  451.       
  452.       public function _hb142(param1:_ni781) : b2Vec2
  453.       {
  454.          return _ui293._db724(param1,m_centroid);
  455.       }
  456.       
  457.       override public function _oa256(param1:_ni781, param2:b2Vec2) : Boolean
  458.       {
  459.          var _loc3_:b2Vec2 = null;
  460.          var _loc4_:_oh327 = null;
  461.          var _loc5_:Number = NaN;
  462.          var _loc6_:Number = NaN;
  463.          var _loc7_:Number = NaN;
  464.          var _loc8_:Number = NaN;
  465.          var _loc9_:int = 0;
  466.          var _loc10_:Number = NaN;
  467.          _loc4_ = param1.R;
  468.          _loc5_ = param2.x - param1.position.x;
  469.          _loc6_ = param2.y - param1.position.y;
  470.          _loc7_ = _loc5_ * _loc4_.col1.x + _loc6_ * _loc4_.col1.y;
  471.          _loc8_ = _loc5_ * _loc4_.col2.x + _loc6_ * _loc4_.col2.y;
  472.          _loc9_ = 0;
  473.          while(_loc9_ < m_vertexCount)
  474.          {
  475.             _loc3_ = m_vertices[_loc9_];
  476.             _loc5_ = _loc7_ - _loc3_.x;
  477.             _loc6_ = _loc8_ - _loc3_.y;
  478.             _loc3_ = m_normals[_loc9_];
  479.             _loc10_ = _loc3_.x * _loc5_ + _loc3_.y * _loc6_;
  480.             if(_loc10_ > 0)
  481.             {
  482.                return false;
  483.             }
  484.             _loc9_++;
  485.          }
  486.          return true;
  487.       }
  488.       
  489.       override public function _bs564(param1:_pv475, param2:_ni781, param3:_ni781) : void
  490.       {
  491.          var _loc4_:_pv475 = null;
  492.          var _loc5_:_pv475 = null;
  493.          _loc4_ = s_sweptAABB1;
  494.          _loc5_ = s_sweptAABB2;
  495.          _mb454(_loc4_,param2);
  496.          _mb454(_loc5_,param3);
  497.          param1.lowerBound._br741(_loc4_.lowerBound.x < _loc5_.lowerBound.x ? _loc4_.lowerBound.x : _loc5_.lowerBound.x,_loc4_.lowerBound.y < _loc5_.lowerBound.y ? _loc4_.lowerBound.y : _loc5_.lowerBound.y);
  498.          param1.upperBound._br741(_loc4_.upperBound.x > _loc5_.upperBound.x ? _loc4_.upperBound.x : _loc5_.upperBound.x,_loc4_.upperBound.y > _loc5_.upperBound.y ? _loc4_.upperBound.y : _loc5_.upperBound.y);
  499.       }
  500.       
  501.       override public function _nw364(param1:b2Vec2) : void
  502.       {
  503.          var _loc2_:b2Vec2 = null;
  504.          var _loc3_:int = 0;
  505.          var _loc4_:Number = NaN;
  506.          var _loc5_:Number = NaN;
  507.          m_sweepRadius = 0;
  508.          _loc3_ = 0;
  509.          while(_loc3_ < m_vertexCount)
  510.          {
  511.             _loc2_ = m_coreVertices[_loc3_];
  512.             _loc4_ = _loc2_.x - param1.x;
  513.             _loc5_ = _loc2_.y - param1.y;
  514.             _loc4_ = Math.sqrt(_loc4_ * _loc4_ + _loc5_ * _loc5_);
  515.             if(_loc4_ > m_sweepRadius)
  516.             {
  517.                m_sweepRadius = _loc4_;
  518.             }
  519.             _loc3_++;
  520.          }
  521.       }
  522.       
  523.       public function _fh374() : Array
  524.       {
  525.          return m_vertices;
  526.       }
  527.       
  528.       public function _py149(param1:_ni781) : b2Vec2
  529.       {
  530.          return _ui293._db724(param1,m_coreVertices[0]);
  531.       }
  532.       
  533.       public function _sc682() : b2Vec2
  534.       {
  535.          return m_centroid;
  536.       }
  537.    }
  538. }
  539.  
  540.